import java.lang.reflect.Array;

public class java_7_31 {
    //作业标题(1704)
    //打印数组
    //
    //作业内容
    //实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
    public static void main(String[] args) {
        int n = 10;
        int[] arr = new int[n];
        printArray(arr);
    }

    private static void printArray(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        for (int a : arr) {
            System.out.print(a + " ");
        }
    }

    //作业内容
    //创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
    public static void main8(String[] args) {
        int[] arr = new int[100];

        for (int i = 0; i < 100; i++) {
            arr[i] = i + 1;
        }
        for (int x : arr) {
            System.out.print(x + " ");
        }
    }

    //递归求解汉诺塔问题
    public static void main7(String[] args) {
        Hanoi(3, 'A', 'B', 'C');
    }

    public static void move(char a, char b) {
        System.out.print(a + "->" + b + " ");
    }

    //pos1起始位置
    //pos2中转位置
    //pos3最终位置
    //下面这个函数的意思是，把a个盘子从A（pos1）起始位置，通过B（pos2）中转位置，放到C（pos3）最终位置
    public static void Hanoi(int a, char pos1, char pos2, char pos3) {
        //A上面只有一个盘子的情况
        if (a == 1) {
            move(pos1, pos3);
            return;//这里必须加return，如果a==1，下面的程序直接结束不需要再执行了
        }
        //把上面a-1个盘子，从A（pos1）起始位置，通过C（pos3）中转位置，放到B（pos2）最终位置
        Hanoi(a - 1, pos1, pos3, pos2);
        //把剩下的那一个盘子直接从A（pos1）放到C（pos3）
        move(pos1, pos3);
        //把刚才的a-1个盘子，从B（pos2）起始位置，通过A（pos1）中转位置，放到C（pos3）最终位置
        Hanoi(a - 1, pos2, pos1, pos3);
    }


    //作业内容
    //递归求斐波那契数列的第 N 项
    public static void main6(String[] args) {
        System.out.println(fib(8));
    }

    public static int fib(int i) {
        if (i == 1 || i == 2)
            return 1;
        return fib(i - 1) + fib(i - 2);
    }


    //返回的数字之和
    //
    //作业内容
    //写一个递归方法，输入一个非负整数，返回组成它的数字之和
    public static void main5(String[] args) {
        System.out.println(SUM(1234));
    }

    public static int SUM(int a) {
        if (a > 9) {
            return SUM(a / 10) + a % 10;
        }
        return a;
    }
    /*public static int SUM(int a) {
        if (a < 9) {
            return a;
        }
        return SUM(a / 10) + a % 10;
    }
*/

    //递归打印数字的每一位
    //
    //作业内容
    //按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4) （递归）
    public static void main4(String[] args) {
        print(1239);
    }

    public static void print(int a) {
        if (a > 9) {
            print(a / 10);
        }
        System.out.print(a % 10 + " ");
    }

    //递归求和
    //
    //作业内容
    //递归求 1 + 2 + 3 + ... + 10
    public static void main3(String[] args) {
        System.out.println(sum(10));
    }

    public static int sum(int a) {
        if (a == 1) {
            return 1;
        }
        return a + sum(a - 1);
    }

    //递归求 N 的阶乘
    public static void main2(String[] args) {
        int x = 5;
        System.out.println(factorial(x));
    }

    public static int factorial(int a) {
        if (a == 1) {
            return 1;
        }
        return a * factorial(a - 1);
    }


    public static void main1(String[] args) {
        System.out.println(find1(123));
    }

    static int sum = 0;

    public static int find1(int num) {

        if (num > 9) {

            find(num / 10);
        }
        sum += num % 10;
        return sum;
    }

    public static int find(int num) {
        int sum = 0;
        if (num < 9) {
            return num;
        }
        return num % 10 + find(num / 10);
    }
}
